{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "单变量特征选择是通过单变量统计检验来选择最好的特征。它可以看作是估计器的预处理步骤。Scikit-learn将特征选择相关功能作为接口进行公开:\n",
    "+ [SelectKBest](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectKBest.html#sklearn.feature_selection.SelectKBest)删除除最高评分外的所有功能\n",
    "+ [SelectPercentile](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectPercentile.html#sklearn.feature_selection.SelectPercentile)删除除用户指定的最高得分百分比以外的所有特征\n",
    "+ 对每个特征使用通用的单变量统计检验：误报率[SelectFpr](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFpr.html#sklearn.feature_selection.SelectFpr)，错误发现率[SelectFdr](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFdr.html#sklearn.feature_selection.SelectFdr)或多重比较谬误率[SelectFwe](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFwe.html#sklearn.feature_selection.SelectFwe)。\n",
    "+ [GenericUnivariateSelect](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.GenericUnivariateSelect.html#sklearn.feature_selection.GenericUnivariateSelect)允许使用可配置策略执行单变量特征选择。这使得我们可以用超参数搜索估计器来选择最佳的单变量选择策略。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 多行输出\r\n",
    "from IPython.core.interactiveshell import InteractiveShell\r\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 1 基本方法\n",
    "## 1.1 SelectKBest\n",
    "导入特征选择库中的SelectKBest和chi2(卡方统计量)用来计算特征间与结果的相关性，并选择相关性最高的特征"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1797, 64)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(1797, 20)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import load_digits\r\n",
    "from sklearn.feature_selection import SelectKBest, chi2\r\n",
    "\r\n",
    "# 获得手写数字数据\r\n",
    "X, y = load_digits(return_X_y=True)\r\n",
    "X.shape\r\n",
    "\r\n",
    "# SelectKBest接收两个参数，使用的计算方法和选取的特征个数\r\n",
    "# SelectKBest默认方法为f_classif，计算提样本的ANOVA F值\r\n",
    "# 选择相关性最高的前20个特征\r\n",
    "X_new = SelectKBest(chi2, k=20).fit_transform(X, y)\r\n",
    "X_new.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "SelectKBest具体特征输出评价如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征选取的结果： [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [3, 3, 3, 3, 3], [0, 1, 1, 1, 1]]\n",
      "特征的得分： [0.11111111 0.         0.4        1.6        3.6       ]\n",
      "特征的p值: [0.73888268 1.         0.52708926 0.20590321 0.05777957]\n",
      "保留的特征列号为： [2 3 4]\n",
      "特征选择后的值 [[3 4 5]\n",
      " [3 2 1]\n",
      " [3 3 3]\n",
      " [1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "X=[[1,2,3,4,5],\r\n",
    "    [5,4,3,2,1],\r\n",
    "    [3,3,3,3,3,],\r\n",
    "    [0,1,1,1,1]]\r\n",
    "\r\n",
    "y=[0,1,0,1]\r\n",
    "\r\n",
    "print(\"特征选取的结果：\",X)\r\n",
    "selector=SelectKBest(chi2,k=3)\r\n",
    "value = selector.fit(X,y).transform(X)\r\n",
    "# 得分越大越好\r\n",
    "print(\"特征的得分：\",selector.scores_)\r\n",
    "print(\"特征的p值:\",selector.pvalues_)\r\n",
    "print(\"保留的特征列号为：\",selector.get_support(True))\r\n",
    "print(\"特征选择后的值\",value)\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 1.2 SelectPercentile\n",
    "SelectPercentile根据最高分数的百分位数选择特征。SelectPercentile方法类似于SelectKBest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1797, 64)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(1797, 7)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import load_digits\r\n",
    "from sklearn.feature_selection import SelectPercentile, chi2\r\n",
    "X, y = load_digits(return_X_y=True)\r\n",
    "X.shape\r\n",
    "\r\n",
    "# SelectPercentile接收两个参数，使用的计算方法和选取得分排名前percentile的特征，第一个参数默认值为f_classif\r\n",
    "X_new = SelectPercentile(chi2, percentile=10).fit_transform(X, y)\r\n",
    "X_new.shape\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "SelectPercentile具体特征输出评价如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征选取的结果： [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [3, 3, 3, 3, 3], [0, 1, 1, 1, 1]]\n",
      "特征的得分： [0.11111111 0.         0.4        1.6        3.6       ]\n",
      "特征的p值: [0.73888268 1.         0.52708926 0.20590321 0.05777957]\n",
      "保留的特征列号为： [4]\n",
      "特征选择后的值 [[5]\n",
      " [1]\n",
      " [3]\n",
      " [1]]\n"
     ]
    }
   ],
   "source": [
    "X=[[1,2,3,4,5],\r\n",
    "    [5,4,3,2,1],\r\n",
    "    [3,3,3,3,3,],\r\n",
    "    [0,1,1,1,1]]\r\n",
    "\r\n",
    "y=[0,1,0,1]\r\n",
    "\r\n",
    "print(\"特征选取的结果：\",X)\r\n",
    "selector=SelectPercentile(chi2,percentile=20)\r\n",
    "value = selector.fit(X,y).transform(X)\r\n",
    "# 得分越大越好\r\n",
    "print(\"特征的得分：\",selector.scores_)\r\n",
    "print(\"特征的p值:\",selector.pvalues_)\r\n",
    "print(\"保留的特征列号为：\",selector.get_support(True))\r\n",
    "print(\"特征选择后的值\",value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 1.3 SelectFpr\n",
    " SelectFpr表示基于假正例率（真实反例被预测为正例的比例 ）的大小进行特征选择"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(569, 30)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(569, 16)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import load_breast_cancer\r\n",
    "from sklearn.feature_selection import SelectFpr, chi2\r\n",
    "X, y = load_breast_cancer(return_X_y=True)\r\n",
    "X.shape\r\n",
    "\r\n",
    "# SelectFpr有两个参数方法和显著性水平\r\n",
    "# alpha也可以理解为保留的特征最高p值\r\n",
    "X_new = SelectFpr(chi2, alpha=0.01).fit_transform(X, y)\r\n",
    "X_new.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "SelectFpr具体特征输出评价如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征选取的结果： [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [3, 3, 3, 3, 3], [0, 1, 1, 1, 1]]\n",
      "特征的得分： [0.11111111 0.         0.4        1.6        3.6       ]\n",
      "特征的p值: [0.73888268 1.         0.52708926 0.20590321 0.05777957]\n",
      "保留的特征列号为： [4]\n",
      "特征选择后的值 [[5]\n",
      " [1]\n",
      " [3]\n",
      " [1]]\n"
     ]
    }
   ],
   "source": [
    "X=[[1,2,3,4,5],\r\n",
    "    [5,4,3,2,1],\r\n",
    "    [3,3,3,3,3,],\r\n",
    "    [0,1,1,1,1]]\r\n",
    "\r\n",
    "y=[0,1,0,1]\r\n",
    "\r\n",
    "print(\"特征选取的结果：\",X)\r\n",
    "selector=SelectFpr(chi2, alpha=0.1)\r\n",
    "value = selector.fit(X,y).transform(X)\r\n",
    "# 得分越大越好\r\n",
    "print(\"特征的得分：\",selector.scores_)\r\n",
    "#  过滤了P值高于alpha(设定)的值\r\n",
    "print(\"特征的p值:\",selector.pvalues_)\r\n",
    "print(\"保留的特征列号为：\",selector.get_support(True))\r\n",
    "print(\"特征选择后的值\",value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 1.4 SelectFdr\n",
    "Bonferroni 校正获得错误发现率。FDR为q value：衡量错误发现率的指标（False discovery rate，简称FDR，所有检验中假阳性的概率）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(569, 30)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(569, 16)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import load_breast_cancer\r\n",
    "from sklearn.feature_selection import SelectFdr, chi2\r\n",
    "X, y = load_breast_cancer(return_X_y=True)\r\n",
    "X.shape\r\n",
    "\r\n",
    "# alpha是预期错误发现率的上限\r\n",
    "X_new = SelectFdr(chi2, alpha=0.01).fit_transform(X, y)\r\n",
    "X_new.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "SelectFdr具体特征输出评价如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征选取的结果： [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [3, 3, 3, 3, 3], [0, 1, 1, 1, 1]]\n",
      "特征的得分： [0.11111111 0.         0.4        1.6        3.6       ]\n",
      "保留的特征列号为： [4]\n",
      "特征选择后的值 [[5]\n",
      " [1]\n",
      " [3]\n",
      " [1]]\n"
     ]
    }
   ],
   "source": [
    "X=[[1,2,3,4,5],\r\n",
    "    [5,4,3,2,1],\r\n",
    "    [3,3,3,3,3,],\r\n",
    "    [0,1,1,1,1]]\r\n",
    "\r\n",
    "y=[0,1,0,1]\r\n",
    "\r\n",
    "print(\"特征选取的结果：\",X)\r\n",
    "selector=SelectFdr(chi2, alpha=0.5)\r\n",
    "value = selector.fit(X,y).transform(X)\r\n",
    "# 得分越大越好\r\n",
    "print(\"特征的得分：\",selector.scores_)\r\n",
    "print(\"保留的特征列号为：\",selector.get_support(True))\r\n",
    "print(\"特征选择后的值\",value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 1.5 SelectFwe\r\n",
    "SelectFwe基于族系误差进行特征选择"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(569, 30)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(569, 15)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import load_breast_cancer\r\n",
    "from sklearn.feature_selection import SelectFwe, chi2\r\n",
    "X, y = load_breast_cancer(return_X_y=True)\r\n",
    "X.shape\r\n",
    "\r\n",
    "# alpha要保留的要素的最高未校正p值。\r\n",
    "X_new = SelectFwe(chi2, alpha=0.01).fit_transform(X, y)\r\n",
    "X_new.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "SelectFwe具体特征输出评价如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征选取的结果： [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [3, 3, 3, 3, 3], [0, 1, 1, 1, 1]]\n",
      "特征的得分： [0.11111111 0.         0.4        1.6        3.6       ]\n",
      "保留的特征列号为： [4]\n",
      "特征选择后的值 [[5]\n",
      " [1]\n",
      " [3]\n",
      " [1]]\n"
     ]
    }
   ],
   "source": [
    "X=[[1,2,3,4,5],\r\n",
    "    [5,4,3,2,1],\r\n",
    "    [3,3,3,3,3,],\r\n",
    "    [0,1,1,1,1]]\r\n",
    "\r\n",
    "y=[0,1,0,1]\r\n",
    "\r\n",
    "print(\"特征选取的结果：\",X)\r\n",
    "selector=SelectFwe(chi2, alpha=0.5)\r\n",
    "value = selector.fit(X,y).transform(X)\r\n",
    "# 得分越大越好\r\n",
    "print(\"特征的得分：\",selector.scores_)\r\n",
    "print(\"保留的特征列号为：\",selector.get_support(True))\r\n",
    "print(\"特征选择后的值\",value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 1.6 GenericUnivariateSelect\r\n",
    "GenericUnivariateSelect可以设置不同的策略来进行单变量特征选择"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(569, 30)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(569, 20)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import load_breast_cancer\r\n",
    "from sklearn.feature_selection import GenericUnivariateSelect, chi2\r\n",
    "X, y = load_breast_cancer(return_X_y=True)\r\n",
    "X.shape\r\n",
    "\r\n",
    "# 参数分别为方法，选择模式，选择多少种特征\r\n",
    "transformer = GenericUnivariateSelect(chi2, mode='k_best', param=20)\r\n",
    "X_new = transformer.fit_transform(X, y)\r\n",
    "X_new.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 2 单变量特征选择特征方法应用\n",
    "## 2.1 单变量特征选择特征方法选择说明\n",
    "单变量特征选择方法就是将特征输入到评分函数，返回一个单变量的f_score(F检验的值)或p-values(P值，假设检验中的一个标准，P-value用来和显著性水平作比较)，注意SelectKBest 和 SelectPercentile只有得分，没有p-value。对于方法的选择推荐如下：\n",
    "+ 回归的数据：f_regression，mutual_info_regression\n",
    "+ 分类的数据：chi2，f_classif，mutual_info_classif\n",
    "\n",
    "如果你使用稀疏数据(比如，使用稀疏矩阵表示的数据), 卡方检验(chi2)、互信息回归(mutual_info_regression)、互信息分类(mutual_info_classif)在处理数据时可保持其稀疏性，因此被推荐选择)。但是要注意的是当心不要在分类问题上使用回归评分函数，将获得无用的结果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 2.2 单变量特征选择特征实例\n",
    "**单变量特征选择**\n",
    "\n",
    "本例中噪声特征会添加到鸢尾花数据中，将鸢尾花的特征数4增值到24，并且会应用单变量特征选择。然后使用SVM进行分类，查看没有进行特征选择是SVM分类器的效果。\n",
    "\n",
    "对于每个特征，我们绘制单变量特征选择的p值以及SVM的相应权重。我们可以看到单变量特征选择会选择信息特征，并且这些特征具有更大的SVM权重。在全部特征中，只有前四个是有意义的。我们可以看到他们在单变量特征选择方面得分最高。SVM会为这些功能之一分配较大的权重，但还会选择许多非重要性功能。在SVM之前应用单变量特征选择会增加归因于重要特征的SVM权重，从而改善分类效率。\n",
    "\n",
    "可以看到未经过特征提取的分类器得分: 0.789，经过特征提取的分类器得分: 0.868"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "未经过特征提取的分类器得分: 0.789\n",
      "经过特征提取的分类器得分: 0.868\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "\r\n",
    "from sklearn.datasets import load_iris\r\n",
    "from sklearn.model_selection import train_test_split\r\n",
    "from sklearn.preprocessing import MinMaxScaler\r\n",
    "from sklearn.svm import LinearSVC\r\n",
    "from sklearn.pipeline import make_pipeline\r\n",
    "from sklearn.feature_selection import SelectKBest, f_classif\r\n",
    "\r\n",
    "# #############################################################################\r\n",
    "# Import some data to play with\r\n",
    "\r\n",
    "# The iris dataset\r\n",
    "# 鸢尾花数据集\r\n",
    "X, y = load_iris(return_X_y=True)\r\n",
    "\r\n",
    "# Some noisy data not correlated\r\n",
    "# 添加噪声\r\n",
    "E = np.random.RandomState(42).uniform(0, 0.1, size=(X.shape[0], 20))\r\n",
    "\r\n",
    "# Add the noisy data to the informative features\r\n",
    "# 添加噪声特征，原来只有四个特征\r\n",
    "X = np.hstack((X, E))\r\n",
    "\r\n",
    "# Split dataset to select feature and evaluate the classifier\r\n",
    "# 分为训练集和测试集\r\n",
    "X_train, X_test, y_train, y_test = train_test_split(\r\n",
    "        X, y, stratify=y, random_state=0\r\n",
    ")\r\n",
    "\r\n",
    "# 新建一个名为figure1窗口\r\n",
    "plt.figure(1)\r\n",
    "# 清除当前 figure 的所有axes，但是不关闭这个 window，所以能继续复用于其他的 plot\r\n",
    "plt.clf()\r\n",
    "\r\n",
    "# 特征标号\r\n",
    "X_indices = np.arange(X.shape[-1])\r\n",
    "\r\n",
    "# #############################################################################\r\n",
    "# Univariate feature selection with F-test for feature scoring\r\n",
    "# We use the default selection function to select the four\r\n",
    "# most significant features\r\n",
    "#基于F检验的特征评分单变量特征选择\r\n",
    "# 我们使用默认的选择函数来选择这四个最显著的特征\r\n",
    "selector = SelectKBest(f_classif, k=4)\r\n",
    "selector.fit(X_train, y_train)\r\n",
    "# 每个特征p值取对数\r\n",
    "scores = -np.log10(selector.pvalues_)\r\n",
    "scores /= scores.max()\r\n",
    "# 每个特征的特征的得分图\r\n",
    "# 蓝色的柱子\r\n",
    "plt.bar(X_indices - .25, scores, width=.2,\r\n",
    "        label=r'Univariate score ($-Log(p_{value})$)')\r\n",
    "\r\n",
    "# #############################################################################\r\n",
    "# Compare to the weights of an SVM\r\n",
    "# 与支持向量机的权重进行比较\r\n",
    "clf = make_pipeline(MinMaxScaler(), LinearSVC())\r\n",
    "\r\n",
    "clf.fit(X_train, y_train)\r\n",
    "# 无特征选择得分\r\n",
    "print('未经过特征提取的分类器得分: {:.3f}'.format(clf.score(X_test, y_test)))\r\n",
    "# 提取权重\r\n",
    "svm_weights = np.abs(clf.named_steps['linearsvc'].coef_).sum(axis=0)\r\n",
    "\r\n",
    "svm_weights /= svm_weights.sum()\r\n",
    "# 橙色的柱子\r\n",
    "plt.bar(X_indices, svm_weights, width=.2, label='SVM weight');\r\n",
    "\r\n",
    "# #############################################################################\r\n",
    "# 特征提取后支持向量机分类\r\n",
    "clf_selected = make_pipeline(\r\n",
    "        SelectKBest(f_classif, k=4), MinMaxScaler(), LinearSVC()\r\n",
    ")\r\n",
    "clf_selected.fit(X_train, y_train)\r\n",
    "print('经过特征提取的分类器得分: {:.3f}'\r\n",
    "      .format(clf_selected.score(X_test, y_test)))\r\n",
    "\r\n",
    "svm_weights_selected = np.abs(clf_selected.named_steps['linearsvc'].coef_).sum(axis=0)\r\n",
    "svm_weights_selected /= svm_weights_selected.sum()\r\n",
    "\r\n",
    "plt.bar(X_indices[selector.get_support()] + .25, svm_weights_selected,\r\n",
    "        width=.2, label='SVM weights after selection')\r\n",
    "\r\n",
    "\r\n",
    "# 特征选择性能比较\r\n",
    "plt.title(\"Comparing feature selection\")\r\n",
    "plt.xlabel('Feature number')\r\n",
    "plt.yticks(())\r\n",
    "plt.axis('tight')\r\n",
    "plt.legend(loc='upper right')\r\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**F检验和相互信息的比较**\n",
    "\n",
    "本例可视化y与三个变量之间的独立关系，并且正则化单变量F检验和互信息（有用的信息度量）二者的计算值。  \n",
    "因F检验只能捕捉线性依赖关系，因此它把x1评为最关键的特征。而互信息能捕捉变量之间所有类型的依赖关系，因此它将x2评为最关键的特征，在这个例子中，它比较符合我们的直观感觉。 两种方法都能正确地把x_3评为不相关特征。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "from sklearn.feature_selection import f_regression, mutual_info_regression\r\n",
    "\r\n",
    "# # 设定随机种子\r\n",
    "np.random.seed(0)\r\n",
    "# # 随机生成包含1000个样本，3个特征值的特征值，值越大越重要\r\n",
    "X = np.random.rand(1000, 3)\r\n",
    "# 计算y值，并指定y值与x各个特征关系\r\n",
    "y = X[:, 0] + np.sin(6 * np.pi * X[:, 1]) + 0.1 * np.random.randn(1000)\r\n",
    "\r\n",
    "# 单变量线性回归测试\r\n",
    "f_test, _ = f_regression(X, y)\r\n",
    "# 将F值结果正则化\r\n",
    "# 测试线性模型中每一个回归因子的的影响\r\n",
    "f_test /= np.max(f_test)\r\n",
    "\r\n",
    "# 互信息计算（有用的信息度量），值越大越重要\r\n",
    "mi = mutual_info_regression(X, y)\r\n",
    "mi /= np.max(mi)\r\n",
    "\r\n",
    "plt.figure(figsize=(15, 5))\r\n",
    "for i in range(3):\r\n",
    "    plt.subplot(1, 3, i + 1)\r\n",
    "    plt.scatter(X[:, i], y, edgecolor='black', s=20)\r\n",
    "    plt.xlabel(\"$x_{}$\".format(i + 1), fontsize=14)\r\n",
    "    if i == 0:\r\n",
    "        plt.ylabel(\"$y$\", fontsize=14)\r\n",
    "    plt.title(\"F-test={:.2f}, MI={:.2f}\".format(f_test[i], mi[i]),\r\n",
    "              fontsize=16)\r\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 3 参考\n",
    "\n",
    "> [https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectKBest.html#sklearn.feature_selection.SelectKBest](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectKBest.html#sklearn.feature_selection.SelectKBest)\n",
    "\n",
    "> [https://www.cnblogs.com/tszr/p/10802025.html](https://www.cnblogs.com/tszr/p/10802025.html)\n",
    "\n",
    "> [https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectPercentile.html#sklearn.feature_selection.SelectPercentile](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectPercentile.html#sklearn.feature_selection.SelectPercentile)\n",
    "\n",
    "> [https://www.cnblogs.com/tszr/p/10802026.html](https://www.cnblogs.com/tszr/p/10802026.html)\n",
    "\n",
    "> [http://lijiancheng0614.github.io/scikit-learn/modules/generated/sklearn.feature_selection.SelectFpr.html](http://lijiancheng0614.github.io/scikit-learn/modules/generated/sklearn.feature_selection.SelectFpr.html)\n",
    "\n",
    "> [https://www.zhihu.com/question/23149768](https://www.zhihu.com/question/23149768)\n",
    "\n",
    "> [https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFdr.html#sklearn.feature_selection.SelectFdr](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFdr.html#sklearn.feature_selection.SelectFdr)\n",
    "\n",
    "> [https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFwe.html#sklearn.feature_selection.SelectFwe](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectFwe.html#sklearn.feature_selection.SelectFwe)\n",
    "\n",
    "> [https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.GenericUnivariateSelect.html#sklearn.feature_selection.GenericUnivariateSelect](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.GenericUnivariateSelect.html#sklearn.feature_selection.GenericUnivariateSelect)\n",
    "\n",
    "> [https://www.cnblogs.com/stevenlk/p/6543628.html](https://www.cnblogs.com/stevenlk/p/6543628.html)\n",
    "\n",
    "> [https://scikit-learn.org/stable/auto_examples/feature_selection/plot_feature_selection.html#sphx-glr-auto-examples-feature-selection-plot-feature-selection-py](https://scikit-learn.org/stable/auto_examples/feature_selection/plot_feature_selection.html#sphx-glr-auto-examples-feature-selection-plot-feature-selection-py)\n",
    "\n",
    "> [https://scikit-learn.org/stable/auto_examples/feature_selection/plot_f_test_vs_mi.html#sphx-glr-auto-examples-feature-selection-plot-f-test-vs-mi-py](https://scikit-learn.org/stable/auto_examples/feature_selection/plot_f_test_vs_mi.html#sphx-glr-auto-examples-feature-selection-plot-f-test-vs-mi-py)\n",
    "\n",
    "> [https://blog.csdn.net/int_line/article/details/100231664](https://blog.csdn.net/int_line/article/details/100231664)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PaddlePaddle 1.8.0 (Python 3.5)",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
